#include <assert.h>
#ifdef WIN32
#include <curses.h>
#else
#include <ncurses.h>
#endif
#include <time.h>
#include "Game.h"

void ncursAff(WINDOW* win, const Jeu * pJeu)
{
	int x,y,xher,yher,k,ismonster;
	int afficher_x,afficher_y;
	int decallage_x,decallage_y;
	int minboucle_x,maxboucle_x;
	int minboucle_y,maxboucle_y;
	int mon_x,mon_y;
	const Terrain * pTer = &(pJeu->ter);
	const Hero * pHero = &(pJeu->her);


	/* Quelle est la taille qu'on affiche */
	afficher_x = 60;
	afficher_y = 18;
	herGetPos(pHero,&xher,&yher);
	wclear(win); /* Effacer L'ecran */
	/* On bouge le map */
	if(getDimx(pTer) < afficher_x){
			decallage_x = -(afficher_x/2 - getDimx(pTer)/2) - 1;
			minboucle_x = 1;
			maxboucle_x = getDimx(pTer)-1;
	}else{
		if(xher <= (afficher_x/2) + 1){
  			decallage_x = 0;
		}else if(getDimx(pTer) - xher <= (afficher_x/2) + 1){
			decallage_x = getDimx(pTer) - (afficher_x + 2);
		}else{
			decallage_x = xher - ((afficher_x/2) + 1);
		}
			minboucle_x = 1+decallage_x;
			maxboucle_x = afficher_x+1+decallage_x;
	}

	if(getDimy(pTer) < afficher_y){
			decallage_y = -(afficher_y/2 - getDimy(pTer)/2) - 1;
			minboucle_y = 0;
			maxboucle_y = getDimy(pTer);
	}else{
		
		if(yher <= (afficher_y/2) + 1){
			decallage_y = 0;
		}else if(getDimy(pTer) - yher <= (afficher_y/2) + 1){
			decallage_y = getDimy(pTer) - (afficher_y + 2);
		}else{
			decallage_y = yher - ((afficher_y/2) + 1);
		}
			minboucle_y = 1+decallage_y;
			maxboucle_y = afficher_y+1+decallage_y;
		}

		/* On parcourt notre terrain et on affiche l'information */
			for (y=minboucle_y;y<maxboucle_y;++y){
		for (x=minboucle_x;x<maxboucle_x;++x){
			
			ismonster = 0;
			for(k=0;k<pJeu->nb_monstre;k++){
				monsterGetPos(&(pJeu->tabmonst[k]), &mon_x, &mon_y);
				if(mon_x == x && mon_y == y)
				if(monsterGetMode(&(pJeu->tabmonst[k])) != 1)
				ismonster = 1;
			}
                if(x==xher&&y==yher)
			mvwprintw( win, y-minboucle_y, x-minboucle_x, "H");
		else if(ismonster)
		 	mvwprintw( win, y-minboucle_y, x-minboucle_x, "M");
		else if(isTeleport(pJeu->tabTeleport,pJeu->nb_teleport,x,y,herGetTerID(pHero))){
			mvwprintw( win, y-minboucle_y, x-minboucle_x, "T");
		}else mvwprintw( win, y-minboucle_y, x-minboucle_x, "%c", terGetXY(pTer,x,y));
		}
		printf("\n");
		}
		wmove( win, yher, xher);
		/* L'information supplimentaire */		
		mvwprintw( win, 18, 0, "----------------------- SKILL ROAD -------------------------\n");
		mvwprintw( win, 19, 0, "Terrain -> Name: %s DIMX: %d DIMY: %d \n",getTerName(pTer), getDimx(pTer), getDimy(pTer));
		mvwprintw( win, 20, 0, "----------------------- INFORMATION ------------------------\n");
		mvwprintw( win, 21, 0, "Hero -> Position: %d %d HP: %d/%d MP: %d/%d Level: %d Exp: %d/%d Attack: %d\n",xher,yher,
			herGetcurhp(pHero),herGethpmax(pHero),
			herGetcurmp(pHero),herGetmpmax(pHero),
			herGetlevel(pHero),herGetcurxp(pHero),
			herGetxpmax(pHero),herGetAttack(pHero));
		if(herGetTarget(pHero) != NULL)
		mvwprintw( win, 22, 0, "Target -> Name: %s HP: %d\n",monsterGetName(herGetTarget(pHero)),monsterGetCurHP(herGetTarget(pHero)));	
		
}

void ncursBoucle(Jeu *pJeu)
{
	WINDOW * win;
	int c;
	int continue_boucle;

	 /* Horloges (en secondes) */
    float horloge_courante, horloge_precedente;

    /* Intervalle de temps (en secondes) entre deux évolutions du jeu */
    float intervalle_horloge = 0.1f;

	initscr();		/* passe l'écran texte en mode NCurses */
	clear();		/* efface l'écran */
	noecho();  	        /* Lorsqu'une touche est préssée au clavier, elle n'apparait pasa à l'écran */
	cbreak();		/* un caractère est directement affiché, il ne passe pas dans un buffer */

	/* Creation d'une nouvelle fenetre en mode texte */
	/* => fenetre de dimension et position ( WIDTH, HEIGHT, STARTX,STARTY) */
	win = newwin(30, 100, 1, 1);
	keypad(win, true);  /* pour que les flèches soient traitées (il faut le faire après création de la fenêtre) */
	nodelay(win, true); /* Pour que l'appel à wgetch soit non-bloquant */

	continue_boucle = 1;

	/* Récupère l'horloge actuelle et la convertit en secondes */
    /* clock() retourne le nombre de tops horloge depuis le lancement du programme */
    horloge_precedente = (float)clock()/(float)CLOCKS_PER_SEC;

    ncursAff( win, pJeu);

	do
	{
        /* Récupère l'horloge actuelle et la convertit en secondes */
        /* clock() retourne le nombre de tops horloge depuis le lancement du programme */
        horloge_courante = (float)clock()/(float)CLOCKS_PER_SEC;

        if (horloge_courante-horloge_precedente>=intervalle_horloge)
        {
                jeuEvolue(pJeu,horloge_courante-horloge_precedente);
                ncursAff( win, pJeu);
                horloge_precedente = horloge_courante;
        }

		c = wgetch(win);

		switch(c)
		{
			case KEY_LEFT:
				jeuActionClavier( pJeu, 'q');
				ncursAff( win, pJeu);
				break;
			case KEY_RIGHT:
				jeuActionClavier( pJeu, 'd');
				ncursAff( win, pJeu);
				break;
			case KEY_UP:
				jeuActionClavier( pJeu, 'z');
				ncursAff( win, pJeu);
				break;
			case KEY_DOWN:
				jeuActionClavier( pJeu, 's');
				ncursAff( win, pJeu);
				break;
			case 'a':
				jeuActionClavier( pJeu, 'a');
				ncursAff( win, pJeu);
				break;
			case 'r':
                    		jeuActionClavier( pJeu, 'r');
				ncursAff( win, pJeu);
				break;
			case 't':
                    		jeuActionClavier( pJeu, 't');
				ncursAff( win, pJeu);
				break;
			case 'y':
                    		jeuActionClavier( pJeu, 'y');
				ncursAff( win, pJeu);
				break;
			case 'u':
                    		jeuActionClavier( pJeu, 'u');
				ncursAff( win, pJeu);
				break;
			case 'e':
                    		jeuActionClavier( pJeu, 'e');
				ncursAff( win, pJeu);
				break;
			case 27: /* ECHAP */
				continue_boucle = 0;
				break;
		}
	} while (continue_boucle==1);

    assert(delwin(win)!=ERR);

	endwin();
}
